/**
 * Copyright(c) 2013 Jade Techonologies Co., Ltd.
 *
 * History:
 *   13-4-14 下午4:28 Created by dwzhang
 */
package com.jade.framework.base.util;

import java.io.Serializable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.BooleanUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;

/**
 * 抽象参数存取.
 *
 * @author dwzhang
 * @version 1.0 13-4-14 下午4:28
 */
public abstract class AbstractParameters implements Parameters, Serializable
{
    /**
     * 返回字符型参数
     *
     * @param key 键值
     * @return 如果找不到返回是<code>#DEFAULT_STRING</code>
     */
    public String getString(String key)
    {
        return getString(key, null);
    }


    /**
     * 返回字符型参数
     *
     * @param key      键值
     * @param defValue 默认值
     * @return 如果找不到返回是<code>defValue</code>
     */
    public String getString(String key, String defValue)
    {
        Object obj = getObject(key);
        if (obj == null) {
            return defValue;
        }
        else {
            return obj.toString();
        }
    }

    /**
     * 返回字符型数组
     *
     * @param key 键值
     * @return 如果找不到返回是<code>#DEFAULT_STRING_ARRAY</code>
     */
    public String[] getStringArray(String key)
    {
        return getStringArray(key, ArrayUtils.EMPTY_STRING_ARRAY);
    }

    /**
     * 返回字符型数组
     *
     * @param key      键值
     * @param defValue 默认值
     */
    public String[] getStringArray(String key, String[] defValue)
    {
        Object obj = getObject(key);
        if (obj == null) {
            return defValue;
        }

        String[] array = null;
        if (obj instanceof String[]) {
            array = (String[])obj;
        }
        else if (obj instanceof String) {
            String str = (String)obj;
            array = toStringArray(str);
        }
        else {

            array = DataUtils.getStringArray(obj, defValue);
        }
        return array == null ? defValue : array;
    }

    /** 字符串到数组的转换 */
    protected String[] toStringArray(String str)
    {
        if (str.indexOf(',') != -1) {
            return StringUtils.split(str, ',');
        }

        if (str.indexOf(';') != -1) {
            return StringUtils.split(str, ';');
        }
        return new String[]{str};
    }

    protected String[] toStringArray(Object[] array)
    {
        //数组
        if (array instanceof Number[] || array instanceof Boolean[] || array instanceof Character[]) {
            String[] strs = new String[array.length];
            for (int i = 0; i < strs.length; i++) {
                strs[i] = array[i].toString();
            }
            return strs;
        }
        return ArrayUtils.EMPTY_STRING_ARRAY;
    }

    /**
     * 返回字节型参数
     *
     * @param key 键值
     * @return 如果找不到返回是<code>#DEFAULT_BYTE</code>
     */
    public byte getByte(String key)
    {
        return getByte(key, NumberUtils.BYTE_ZERO);
    }

    /**
     * 返回字节型参数
     *
     * @param key      键值
     * @param defValue 默认值
     * @return 如果找不到返回是<code>defValue</code>
     */
    public byte getByte(String key, byte defValue)
    {
        return DataUtils.getByte(getObject(key), defValue);
    }

    /**
     * 返回字符型参数
     *
     * @param key 键值
     * @return 如果找不到返回是<code>#DEFAULT_BYTE</code>
     */
    public char getChar(String key)
    {
        return getChar(key, DEFAULT_CHAR);
    }

    public static final char DEFAULT_CHAR = '\0';

    /**
     * 返回字符型参数
     *
     * @param key      键值
     * @param defValue 默认值
     * @return 如果找不到返回是<code>defValue</code>
     */
    public char getChar(String key, char defValue)
    {
        return DataUtils.getChar(getObject(key), defValue);
    }

    /**
     * 返回字节型数组
     *
     * @return 如果找不到返回是<code>#DEFAULT_BYTE_ARRAY</code>
     */
    public byte[] getByteArray(String key)
    {
        return getByteArray(key, ArrayUtils.EMPTY_BYTE_ARRAY);
    }

    /**
     * 返回字节型数组
     *
     * @param key      键值
     * @param defValue 默认值
     * @return 字节型数组
     */
    public byte[] getByteArray(String key, byte[] defValue)
    {
        return DataUtils.getByteArray(getObject(key), defValue);
    }

    /**
     * 返回字符型数组
     *
     * @param key 键值
     * @return 如果找不到返回是<code>#DEFAULT_BYTE_ARRAY</code>
     */
    public char[] getCharArray(String key)
    {
        return getCharArray(key, ArrayUtils.EMPTY_CHAR_ARRAY);
    }

    /**
     * 返回字符型数组
     *
     * @param key      键值
     * @param defValue 默认值
     * @return 字节型数组
     */
    public char[] getCharArray(String key, char[] defValue)
    {
        return DataUtils.getCharArray(getObject(key), defValue);
    }


    /**
     * 返回布尔型参数
     *
     * @param key 键值
     * @return 如果找不到返回是<code>#DEFAULT_BOOLEAN</code>
     */
    public boolean getBoolean(String key)
    {
        return getBoolean(key, false);
    }

    /**
     * 返回布尔型参数
     *
     * @param key      键值
     * @param defValue 默认值
     * @return 如果找不到返回是<code>defValue</code>
     */
    public boolean getBoolean(String key, boolean defValue)
    {
        return DataUtils.getBoolean(getObject(key), defValue);
    }

    /**
     * 返回布尔型数组
     *
     * @return 如果找不到返回是<code>#DEFAULT_BOOLEAN_ARRAY</code>
     */
    public boolean[] getBooleanArray(String key)
    {
        return getBooleanArray(key, ArrayUtils.EMPTY_BOOLEAN_ARRAY);
    }

    /**
     * 返回布尔型数组
     *
     * @param key      键值
     * @param defValue 默认值
     * @return 布尔型数组
     */
    public boolean[] getBooleanArray(String key, boolean[] defValue)
    {
        return DataUtils.getBooleanArray(getObject(key), defValue);
    }

    /**
     * 返回短整数型参数
     *
     * @param key 键值
     * @return 如果找不到返回是<code>#DEFAULT_SHORT</code>
     */
    public short getShort(String key)
    {
        return getShort(key, NumberUtils.SHORT_ZERO);
    }

    /**
     * 返回短整数型参数
     *
     * @param key      键值
     * @param defValue 默认值
     * @return 如果找不到返回是<code>defValue</code>
     */
    public short getShort(String key, short defValue)
    {
        return DataUtils.getShort(getObject(key), defValue);
    }

    /**
     * 返回短整型数组
     *
     * @return 如果找不到返回是<code>#DEFAULT_SHORT_ARRAY</code>
     */
    public short[] getShortArray(String key)
    {
        return getShortArray(key, ArrayUtils.EMPTY_SHORT_ARRAY);
    }

    /**
     * 返回短整型数组
     *
     * @param key      键值
     * @param defValue 默认值
     * @return 短整型数组
     */
    public short[] getShortArray(String key, short[] defValue)
    {
        return DataUtils.getShortArray(getObject(key), defValue);
    }

    /**
     * 返回整数型参数
     *
     * @param key 键值
     * @return 如果找不到返回是<code>#DEFAULT_INT</code>
     */
    public int getInt(String key)
    {
        return getInt(key, NumberUtils.INTEGER_ZERO);
    }

    /**
     * 返回整数型参数
     *
     * @param key      键值
     * @param defValue 默认值
     * @return 如果找不到返回是<code>defValue</code>
     */
    public int getInt(String key, int defValue)
    {
        return DataUtils.getInt(getObject(key), defValue);
    }

    /**
     * 返回整数型数组
     *
     * @param key 键值
     * @return 如果找不到返回是<code>#DEFAULT_INT_ARRAY</code>
     */
    public int[] getIntArray(String key)
    {
        return getIntArray(key, ArrayUtils.EMPTY_INT_ARRAY);
    }

    /**
     * 返回整型数组
     *
     * @param key      键值
     * @param defValue 默认值
     * @return 整型数组
     */
    public int[] getIntArray(String key, int[] defValue)
    {
        Object obj = getObject(key);
        if (obj == null) {
            return defValue;
        }

        int[] array = null;
        if (obj instanceof int[]) {
            array = (int[])obj;
        }
        else if (obj instanceof Number) {
            Number number = (Number)obj;
            array = new int[]{number.intValue()};
        }
        else if (obj instanceof String) {
            array = toIntArray((String)obj);
        }
        else {
            array = DataUtils.getIntArray(obj, defValue);
        }

        return array == null ? defValue : array;
    }

    /** 字符串到整数数组的转换 */
    protected int[] toIntArray(String str)
    {
        str = str.replace(';', ',');
        return DataUtils.getIntArray(str, ArrayUtils.EMPTY_INT_ARRAY);
    }

    /**
     * 返回浮点数参数
     *
     * @param key 键值
     * @return 如果找不到返回是<code>#DEFAULT_FLOAT</code>
     */
    public float getFloat(String key)
    {
        return getFloat(key, NumberUtils.FLOAT_ZERO);
    }

    /**
     * 返回浮点数参数
     *
     * @param key      键值
     * @param defValue 默认值
     * @return 如果找不到返回是<code>defValue</code>
     */
    public float getFloat(String key, float defValue)
    {
        return DataUtils.getFloat(getObject(key), defValue);
    }

    /**
     * 返回浮点型数组
     *
     * @return 如果找不到返回是<code>#DEFAULT_FLOAT_ARRAY</code>
     */
    public float[] getFloatArray(String key)
    {
        return getFloatArray(key, ArrayUtils.EMPTY_FLOAT_ARRAY);
    }

    /**
     * 返回浮点型数组
     *
     * @param key      键值
     * @param defValue 默认值
     * @return 浮点型数组
     */
    public float[] getFloatArray(String key, float[] defValue)
    {
        return DataUtils.getFloatArray(getObject(key), defValue);
    }

    /**
     * 返回高精度浮点数参数
     *
     * @param key 键值
     * @return 如果找不到返回是<code>#DEFAULT_DOUBLE</code>
     */
    public double getDouble(String key)
    {
        return getDouble(key, NumberUtils.DOUBLE_ZERO);
    }

    /**
     * 返回浮点数参数
     *
     * @param key      键值
     * @param defValue 默认值
     * @return 如果找不到返回是<code>defValue</code>
     */
    public double getDouble(String key, double defValue)
    {
        return DataUtils.getDouble(getObject(key), defValue);
    }

    /**
     * 返回高精度浮点型数组
     *
     * @return 如果找不到返回是<code>#DEFAULT_DOUBLE_ARRAY</code>
     */
    public double[] getDoubleArray(String key)
    {
        return getDoubleArray(key, ArrayUtils.EMPTY_DOUBLE_ARRAY);
    }

    /**
     * 返回高精度浮点型数组
     *
     * @param key      键值
     * @param defValue 默认值
     * @return 高精度浮点型数组
     */
    public double[] getDoubleArray(String key, double[] defValue)
    {
        return DataUtils.getDoubleArray(getObject(key), defValue);
    }

    /**
     * 返回长整型参数
     *
     * @param key 键值
     * @return 如果找不到返回是<code>#DEFAULT_LONG</code>
     */
    public long getLong(String key)
    {
        return getLong(key, NumberUtils.LONG_ZERO);
    }

    /**
     * 返回长整型参数
     *
     * @param key      键值
     * @param defValue 默认值
     * @return 如果找不到返回是<code>defValue</code>
     */
    public long getLong(String key, long defValue)
    {
        return DataUtils.getLong(getObject(key), defValue);
    }

    /**
     * 返回长整型数组
     *
     * @return 如果找不到返回是<code>#DEFAULT_LONG_ARRAY</code>
     */
    public long[] getLongArray(String key)
    {
        return getLongArray(key, ArrayUtils.EMPTY_LONG_ARRAY);
    }

    /**
     * 返回长整型数组
     *
     * @param key      键值
     * @param defValue 默认值
     * @return 长整型数组
     */
    public long[] getLongArray(String key, long[] defValue)
    {
        return DataUtils.getLongArray(getObject(key), defValue);
    }

    /**
     * 返回对象型参数
     *
     * @param key      键值
     * @param defValue 默认值
     * @return 如果找不到返回是<code>defValue</code>
     */
    public Object getObject(String key, Object defValue)
    {
        Object value = getObject(key);
        return value == null ? defValue : value;
    }

    /**
     * 返回对象数组
     * <p/>
     * param key 键值
     *
     * @return 对象数组，如果找不到返回<code>null</code>
     */
    public Object[] getObjectArray(String key)
    {
        return getObjectArray(key, null);
    }

    /**
     * 返回对象数组
     *
     * @param key      键值
     * @param defValue 默认值
     */
    public Object[] getObjectArray(String key, Object[] defValue)
    {
        Object obj = getObject(key);
        if (obj == null) {
            return defValue;
        }
        if (obj instanceof Object[]) {
            return (Object[])obj;
        }
        else {
            return new Object[]{obj};
        }
    }

    /**
     * 设置整型的参数
     *
     * @param key   键值
     * @param value 整数型数值
     */
    public void setInt(String key, int value)
    {
        setObject(key, new Integer(value));
    }


    /**
     * 设字节型参数
     *
     * @param key   键值
     * @param value 字节型
     */
    public void setByte(String key, byte value)
    {
        setObject(key, new Byte(value));
    }

    /**
     * 设字符型参数
     *
     * @param key   键值
     * @param value 字节型
     */
    public void setChar(String key, char value)
    {
        setObject(key, new Character(value));
    }


    /**
     * 设置短整型的参数
     *
     * @param key   键值
     * @param value 短整型数值
     */
    public void setShort(String key, short value)
    {
        setObject(key, new Short(value));
    }


    /**
     * 设置布尔型参数
     *
     * @param key   键值
     * @param value 布尔型
     */
    public void setBoolean(String key, boolean value)
    {
        setObject(key, BooleanUtils.toBoolean(value));
    }

    /**
     * 设置长整型参数
     *
     * @param key   键值
     * @param value 长整型
     */
    public void setLong(String key, long value)
    {
        setObject(key, new Long(value));
    }

    /**
     * 设置浮点型参数
     *
     * @param key   键值
     * @param value 浮点型
     */
    public void setFloat(String key, float value)
    {
        setObject(key, new Float(value));
    }

    /**
     * 设置高精度浮点型参数
     *
     * @param key   键值
     * @param value 浮点型
     */
    public void setDouble(String key, double value)
    {
        setObject(key, new Double(value));
    }

    /**
     * 设置字符型参数
     *
     * @param key   键值
     * @param value 字符串型
     */
    public String setString(String key, String value)
    {
        Object obj = setObject(key, value);
        if (obj != null) {
            return obj.toString();
        }
        return null;
    }

    /**
     * 添加Parameters
     *
     * @param param 参数集合
     */
    public void putAll(Parameters param)
    {
        if (param != null) {
            Iterator names = param.getNames();
            while (names.hasNext()) {
                String name = (String)names.next();
                Object value = param.getObject(name);
                setObject(name, value);
            }
        }
    }

    /**
     * insert a whole map
     *
     * @param map map
     */
    public void putAll(Map<String, ?> map)
    {
        if (map != null) {
            Set<String> keys = map.keySet();
            for (String s : keys) {
                setObject(s, map.get(s));
            }
        }
    }

    /** 是否为空 */
    public boolean isEmpty()
    {
        return size() == 0;
    }

    /**
     * 返回各种数据类型对象
     *
     * @return 对象枚举
     */
    public Iterator getValues()
    {
        return CollectionUtils.EMPTY_COLLECTION.iterator();
    }

    /** 数目 */
    public int size()
    {
        return 0;
    }

    /** 清除所有的参数 */
    public void clear()
    {
    }
}

